home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / New System Software Extensions / Thread Manager Extension 2.0.1 / Sample Applications / Power Examples / SortPicts / Source / WindowObj.cp < prev    next >
Encoding:
Text File  |  1994-06-03  |  10.4 KB  |  477 lines  |  [TEXT/MPS ]
  1. /*************************************************************************************
  2.  *
  3.  *    Object Oriented Shell
  4.  *
  5.  *    WindowObj.cp - C Source
  6.  *
  7.  *      Copyright © Apple Computer, Inc. 1988 - 1993
  8.  *      All rights reserved.
  9.  *
  10.  *   This file defines the basic window functions.  As it turns out, if you
  11.  *     (Yeah, I'm talkin' to you) pull out GWorldObj.cp (& the two sort algorithms)
  12.  *     and modify WindowObj.Link -- you could use the ENTIRE source code here
  13.  *     (Events, Windows, Traps, Main, etc) to support your own applications.
  14.  *     But I won't go into that here.
  15.  *
  16.  *************************************************************************************/
  17.  
  18. #include "WindowObj.h"
  19. #include "main.h"
  20. #include "WindowObj.Link"        // This is your interface file that defines your stuff
  21.  
  22. // Initialize the global
  23. Boolean    WindowObj::isColor = false;
  24.  
  25. //  NewWindowObj
  26. //    This needs to be called immediately after the
  27. //            obj *a = new obj;
  28. //      As in:
  29. //            a->NewWindowObj();
  30.  
  31. Boolean  WindowObj :: NewWindowObj( void)
  32. {
  33.     Rect        boundsRect;
  34.  
  35.  
  36.     
  37.     /*  One of the neat things about the THINK C constructor is it fills the instance
  38.         memory with zerøs which ensures that the variable "me" will be zerø upon startup */
  39.     if( me == NIL)                        //  Each object can only have 1 window
  40.     {                                    //  Unless programmed otherwise...
  41.         SetRect( &boundsRect, 40, 40, 500, 340);
  42.         
  43.         if( isColor == true)
  44.         {
  45.             me = NewCWindow( NIL, &boundsRect, (ConstStr255Param)"\pUntitled", true, 0, (WindowPtr)-1, true, 
  46.                 /* CRITICALLY IMPORTANT:: */   (long) this);
  47.         }
  48.         else
  49.         {
  50.             me = NewWindow( NIL,             //  I have not declared a space for the window
  51.                             &boundsRect,     //    The boundary is 40,40, 140,140 in global coords
  52.         (ConstStr255Param)    "\pUntitled",    //  The title is "Untitled"
  53.                             true,             //  Make it visible
  54.                             0,                //  DocumentProc type window (title, close, zoom, grow)
  55.                             (WindowPtr)-1,        //  Make it the front window
  56.                             true,            //  Give it a goAway box
  57.     /* CRITICAL:: */ (long) this);            //  RefCon:  Give it the address of this object!!
  58.         }
  59.         if( me != NIL)
  60.         {
  61.             SetPort( me);
  62.             ((WindowPeek)me)->windowKind = WindowObjKind;
  63.         }
  64.     }
  65.     if( me == nil)
  66.         return false;
  67.     else
  68.         return true;
  69. }
  70.  
  71.  
  72. /***************************************************************************
  73.  
  74.     InitObj
  75.     
  76.     This function performs basic initialization that all of your windows can use.
  77.     If you have any menus or other resources you want to load in at system start time,
  78.     define a subordinant function of this and then call this function from inside it.
  79.     
  80.  ***************************************************************************/
  81.  void    WindowObj :: InitObj( void)
  82.  {
  83. //     char    objName[32];
  84. //    int        fileRef;
  85. //    int        objNameLen;
  86.     
  87.     isColor = gMac.hasColorQD;        // Retain the color bit
  88.     useActivateClicks = false;        // Do not interpret activate events as action events
  89.  }
  90.  
  91.  
  92. Boolean  WindowObj :: CloseWindowObj( void)
  93. {
  94.     if( me != NIL)                            //    You'll probably overide this code
  95.     {                                        //  With your own that checks the dirtyFlag
  96.         DisposeWindow( me);                    //  Call the Mac to eliminate the window!
  97.         me = NIL;                            //  Take notice that the window is gone.
  98.     }
  99.     return true;
  100. }
  101.  
  102.  
  103. void  WindowObj :: SetWindowTitle( Str255    *title)
  104. {
  105.     SetWTitle( me, (ConstStr255Param)title);
  106. }
  107.  
  108. void  WindowObj :: IdleObj( void)
  109. {
  110.     /* Do nothing during an Idle event ... */
  111. }
  112.  
  113.  
  114. /********************************************************************************
  115.  
  116.     AdjustMenus
  117.     
  118.     If there are any differences in the menu structure of a new Window Object,
  119.     the new object must rewrite this code, there's just no way around it.
  120.  
  121.     However, I encourage authors to copy and paste these elements!!
  122.     (That might help to speed the process.)
  123.  
  124.  ********************************************************************************/
  125.  
  126. void  WindowObj :: AdjustMenusObj( void)
  127. {
  128.     MenuHandle    menu;
  129.  
  130.     menu = GetMHandle( mFile);            // Do the File menu first
  131.     EnableItem(menu, iNew);                // Enable the items, one at a time...
  132.     EnableItem(menu, iOpen);
  133.     if( me != NIL)
  134.     {
  135.         EnableItem(menu, iClose);
  136.         EnableItem(menu, iSave);
  137.         EnableItem(menu, iSaveAs);
  138.         EnableItem(menu, iRevert);
  139.         EnableItem(menu, iPageSetup);
  140.         EnableItem(menu, iPrint);
  141.     }
  142.     else
  143.     {
  144.         DisableItem(menu, iClose);
  145.         DisableItem(menu, iSave);
  146.         DisableItem(menu, iSaveAs);
  147.         DisableItem(menu, iRevert);
  148.         DisableItem(menu, iPageSetup);
  149.         DisableItem(menu, iPrint);
  150.     }
  151.     EnableItem(menu, iQuit);
  152.         
  153.     menu = GetMHandle( mEdit);
  154.     DisableItem(menu, iUndo);
  155.     DisableItem(menu, iCut);
  156.     DisableItem(menu, iCopy);
  157.     DisableItem(menu, iClear);
  158.     DisableItem(menu, iPaste);
  159. }
  160.  
  161.  
  162. void  WindowObj :: KeyPressObj( EventRecord *event)
  163. {
  164.     int a = 0;
  165.     if( a != 0)
  166.         event->modifiers = 0;
  167. }
  168.  
  169.  
  170. void  WindowObj :: MouseClickObj( EventRecord *event)
  171. {
  172.     int        a = 0;
  173.     //  Notice that the shell takes care of:
  174.     //        Dragging, zooming, tracking, etc.
  175.     //  This code only needs to worry about scroll bars,
  176.     //  other controls, and the content region!!
  177.     if( a != 0)
  178.         event->modifiers = 0;
  179. }
  180.  
  181.  
  182. void  WindowObj :: UpdateObj( void)
  183. {
  184.  
  185. #ifdef debugFlag
  186.     DebugStr( "\pUpdate routine in WindowObj");
  187. #endif
  188.     EraseRgn(me->visRgn);    // By default, erase me... then redraw
  189.     DrawObj();    // By default, updating is drawing... until you specify otherwise
  190.                 // But this algorithm is next to lame. So you'll probably want to
  191.                 // write your own UpdateObj() routine.  Just as soon as
  192.                 // you get the rest of your App up and running!
  193. }
  194.  
  195.  
  196. void  WindowObj :: DrawObj( void)
  197. {
  198.  
  199. }
  200.  
  201. void  WindowObj :: PageSetupObj( void)
  202. {
  203. #ifdef debugFlag
  204.     DebugStr( "\pPageSetupObj!!");
  205. #endif
  206.     if( myPrintInfo == (void *)0 )
  207.     {
  208.         myPrintInfo = (THPrint) NewHandle( sizeof( TPrint));
  209.     }
  210.     PrOpen();
  211.     PrStlDialog( myPrintInfo);
  212.     PrClose();
  213. }
  214.  
  215. void  WindowObj :: PrintObj( void)
  216. {
  217.     GrafPtr            saveMe;        // Save the "me" in the case that
  218.                                 // the DrawCode changes GrafPtr's to "me"
  219.                                 // P.S.:  This ONLY works because WaitNextEvent
  220.                                 //          isn't ever called in the middle of
  221.                                 //          printing.  Updating (a possible outcome
  222.                                 //          of W.N.E.) requires "me" to be set right!!
  223.     TPPrPort        myPrintPort;
  224.     
  225.     if( myPrintInfo == (void *)0 )
  226.     {
  227.         PageSetupObj();
  228.     }
  229.     PrOpen();
  230.     if( PrJobDialog( myPrintInfo))
  231.     {
  232.         SetOutlinePreferred( true);    // System 7.0 Support for TrueType
  233.  
  234.         myPrintPort = PrOpenDoc( myPrintInfo, (TPrPort *)0, (Ptr)0);
  235.         if( PrError() == noErr)
  236.         {
  237.             saveMe = me;
  238.             me = (GrafPtr) myPrintPort;
  239.             PrOpenPage( myPrintPort, (Rect *)0);
  240.             if( PrError() == noErr)
  241.             {
  242.                 DrawObj();
  243.             }
  244.             PrClosePage( myPrintPort);
  245.         }
  246.         PrCloseDoc( myPrintPort);    
  247.         me = saveMe;
  248.     }
  249.     PrClose();
  250. }
  251.  
  252. void  WindowObj :: CutObj( EventRecord *event)
  253. {
  254.     long int    oserror;
  255.     int        a = 0;
  256.     if( a != 0)
  257.         event->modifiers = 0;
  258.  
  259.     oserror = ZeroScrap();        // Clear the deskScrap file
  260. }
  261.  
  262. void  WindowObj :: CopyObj( EventRecord *event)
  263. {
  264.     long int    oserror;
  265.     int            a = 0;
  266.     
  267.     if( a != 0)
  268.         event->modifiers = 0;
  269.     
  270.     oserror = ZeroScrap();        // Clear the deskScrap file
  271. }
  272.  
  273.  
  274. void  WindowObj :: PasteObj( EventRecord *event)
  275. { 
  276.     //    No code because I don't know which TYPE the program wants
  277.     int            a = 0;
  278.     if( a != 0)
  279.         event->modifiers = 0;
  280. }
  281.  
  282. void  WindowObj :: UndoObj( EventRecord *event)
  283. {
  284.     //  Undo's need to be handled by the individual window
  285.     int            a = 0;
  286.     if( a != 0)
  287.         event->modifiers = 0;
  288. }
  289.  
  290. void  WindowObj :: DeleteObj( EventRecord *event)
  291. {
  292.     int            a = 0;
  293.     if( a != 0)
  294.         event->modifiers = 0;
  295. }
  296.  
  297. void  WindowObj :: ConvertScrapObj( void)
  298. {
  299.     // Again, nothing here
  300. }
  301.  
  302. void  WindowObj :: ActivateObj( Boolean becomingActive)
  303. {
  304.     if( becomingActive == true)
  305.     {
  306.         if( me != NIL)
  307.         {
  308.             SelectWindow( me);
  309.             this->DrawGrowIconObj();
  310.         }
  311.     }
  312. }
  313.  
  314.  
  315. void  WindowObj :: MenuObj( short menuID, short menuItem, EventRecord *event)
  316. {
  317.     short            b =0;
  318.     WINDOWOBJ       *a;
  319.  
  320.     if( b != 0)
  321.         event->modifiers = 0;
  322.  
  323.     switch( menuID )
  324.     {
  325.         case mFile:
  326.             switch( menuItem)
  327.             {
  328.                 case iNew:
  329.                     a = new WINDOWOBJ;
  330.                     if( a)
  331.                     {
  332.                         a->me = (WindowPtr) 0;
  333.                         if( a->NewWindowObj() == false)
  334.                             delete a;
  335.                     }
  336.                     break;
  337.                 case iClose:
  338.                     CloseWindowObj();
  339.                     break;
  340.                 case iPageSetup:
  341.                     PageSetupObj();
  342.                     break;
  343.                 case iPrint:
  344.                     PrintObj();
  345.                     break;
  346.                 default:
  347.                     AppMenu( menuID, menuItem);        // This is like inheritance!!
  348.                     break;
  349.             }
  350.             break;
  351.             
  352.         default:
  353.             AppMenu( menuID, menuItem);                // This is like inheritance!!
  354.             break;
  355.     }
  356.     HiliteMenu(0);
  357. }
  358.  
  359.  
  360. void  WindowObj :: AdjustCursorObj( Point mouseLoc, RgnHandle cursorRgn)
  361. {
  362.     /* This routine doesn't use the mouseLocation, but your windows can! */
  363.     if( cursorRgn != NIL)        // From your window code, you can call AdjustCursor
  364.     {                            // with NIL and this routine will simply adjust the cursor
  365.         SetEmptyRgn( cursorRgn);// you should try incorporating it into your code, too.
  366.     }
  367.     SetCursor( &qd.arrow);
  368.     if( mouseLoc.h == -5000)
  369.         ;
  370. }
  371.  
  372.  
  373.  
  374.  
  375. void  WindowObj :: DrawGrowIconObj( void)
  376. {
  377.     WindowPtr    copyMe = me;
  378.     
  379.     if( me != NIL)
  380.     {
  381.         DrawGrowIcon( me);
  382.     }
  383. }
  384.  
  385. void    WindowObj :: DragWindowObj( EventRecord *event)
  386. {
  387.     DragWindow( me, event->where, &qd.screenBits.bounds);
  388. }
  389.  
  390.  
  391. void    WindowObj :: GrowWindowObj( EventRecord *event)
  392. {
  393.     Rect        growRect;
  394.     long        newSize;
  395.  
  396.     growRect = qd.screenBits.bounds;
  397.     growRect.top = growRect.left = 80;        /* Arbitrary minimum size */
  398.     newSize = GrowWindow( me, event->where, &growRect);
  399.     if( newSize != 0)
  400.     {
  401.         InvalidateScrollbars( me);
  402.         SizeWindow( me, LoWrd(newSize), HiWrd(newSize), true);
  403.         InvalidateScrollbars( me);
  404.     }
  405. }
  406.  
  407.  
  408. void    WindowObj :: ZoomWindowObj( EventRecord *event, Boolean OutIsTrue)
  409. {
  410.     if( event->modifiers == 0x8000)
  411.         OutIsTrue = true;
  412. }
  413.  
  414.  
  415. void    WindowObj :: ScrollWindowObj( EventRecord *event)
  416. {
  417.     if( event->modifiers == 0x8000)
  418.         ;
  419. }
  420.  
  421.  
  422. void    WindowObj :: DiskInsertObj( EventRecord *event)
  423. {
  424.     Point            aPoint = {100, 100};
  425.         if( HiWrd(event->message) != noErr)
  426.         {
  427.             (void) DIBadMount(aPoint, event->message);
  428.         }
  429. }
  430.  
  431. short int    WindowObj :: DrawingWidth( void)
  432. {
  433.     if( me)
  434.     {
  435.         short int        width = me->portRect.right - me->portRect.left;
  436.         WindowPeek        winObj = (WindowPeek)me;
  437.         short int        myKind = winObj -> windowKind;
  438.         
  439.         if( myKind == 0 || myKind == 8)
  440.             return width - 16;
  441.         else
  442.             return    width;
  443.     }
  444.     else
  445.         return 0;
  446. }
  447.  
  448. short int    WindowObj :: DrawingHeight( void)
  449. {
  450.     if( me)
  451.     {
  452.         short int        height = me->portRect.bottom - me->portRect.top;
  453.         WindowPeek        winObj = (WindowPeek)me;
  454.         short int        myKind = winObj -> windowKind;
  455.         
  456.         if( myKind == 0 || myKind == 8)
  457.             return height - 16;
  458.         else
  459.             return    height;
  460.     }
  461.     else
  462.         return 0;
  463. }
  464.  
  465. void    WindowObj :: DrawingRect( Rect *area)
  466. {
  467.     if( me)
  468.     {
  469.         *area = me -> portRect;
  470.         area->right = area->left + DrawingWidth();
  471.         area->bottom = area->top + DrawingHeight();
  472.     }
  473.     else
  474.         SetRect( area, 0, 0, 0, 0);
  475. }
  476.  
  477.